home *** CD-ROM | disk | FTP | other *** search
- //***************************************************************************
- // OATH :: Object-oriented Abstract Type Hierarchy
- //***************************************************************************
- //
- // Copyright (C) 1991, 1990 Texas Instruments Incorporated
- // Permission is granted to any individual or institution
- // to use, copy, modify, and distribute this software,
- // provided that this complete copyright and permission notice
- // is maintained, intact, in all copies and supporting documentation.
- //
- // Texas Instruments Incorporated provides this software "as is"
- // without express or implied warranty.
- //
- //***************************************************************************
- // stringToken (stringTokenA, stringTokenG)
- // stringTable (stringTableA, stringTableG)
- //
- // History:
- // 07/91 Brian M Kennedy import, export, typeRegister
- // 06/91 Brian M Kennedy New macros & format; remove printDiagnostic
- // 10/90 Brian M Kennedy Major Rewrite
- // 02/90 Brian M Kennedy Original
- //
- //***************************************************************************
-
- #include "copyright.h"
-
- #include <oath/stringTable.h>
-
- #define OATH_STRING_TOKEN_BUCKETS 255
-
- #include <iostream.h>
-
- /////////////////////////////////////////////////////////////////////////////
- /////////////////////////////////////////////////////////////////////////////
- // stringToken Outlines
-
- OUTLINES(stringToken, token)
-
- stringTableA stringTokenG::
- StringTokens = stringTableA::make(OATH_STRING_TOKEN_BUCKETS);
-
- // Constructors //////////
-
- stringTokenG::
- stringTokenG (const minStringG* IString)
- :tokenG(), String(IString)
- {ref();
- {if(!String.isConst())
- String = String.makeCopy(TRUE);
- HashCache = String.hash();
- StringTokens.guts()->insertAssoc(this, Nil);
- }
- deref();
- }
-
- stringTokenG::
- ~stringTokenG ()
- {ref();
- {// cannot yet remove from existence
- }
- deref();
- }
-
-
- // oathCore Operations //////////
-
- void stringTokenG::
- export (exportP& X) const
- {X.writeType(TypeName);
- String.export(X);
- }
-
- objA stringTokenG::
- import (importP& M)
- {minStringA String = minStringA::isa(objA::import(M));
- return stringTokenA::make(String);
- }
-
-
- /////////////////////////////////////////////////////////////////////////////
- /////////////////////////////////////////////////////////////////////////////
- // stringTable Outlines
-
- OUTLINES(stringTable, table)
-
- // Constructors //////////
-
- stringTableG::
- stringTableG (unsigned int IBuckets, int IsConst)
- :tableG(IsConst), Table(0), Count(0), Buckets(IBuckets)
- {ref();
- Table = (stNodeP**)(new stNodeP* [IBuckets]);
- for(unsigned int I = 0; I < Buckets; I++)
- Table[I] = 0;
- deref();
- }
-
- // oathCore Operations //////////
-
- void stringTableG::
- export (exportP& X) const
- {X.writeType(TypeName);
- X.stream() << Buckets << ' ' << Count << (isConst() ? ' ' : '\0');
- for(unsigned int I = 0; I < Buckets; ++I)
- for(stNodeP* N = Table[I]; N; N = N->Next)
- N->Obj.export(X);
- }
-
- objA stringTableG::
- import (importP& M)
- {int Buckets, Count;
- M.stream() >> Buckets >> Count;
- char MakeConst = M.stream().get();
- stringTableA ST = stringTableA::make(Buckets);
- for(int I = 0; I < Count; ++I)
- ST << stringTokenA::isa(objA::import(M)).am();
- if(MakeConst)
- ST.guts()->forceConst();
- return ST;
- }
-
-
- // obj Operations //////////
-
- int stringTableG::
- isEqual (const objG* O) const
- {ensure(is(O), "Not implemented.");
- return TRUE;
- }
-
- objA stringTableG::
- makeCopy (int) const // ignores MakeConst argument
- {bagA ST = makeEmpty();
- applyX(callSelf, ST.guts());
- return Nil;
- }
-
-
- // bag Operations //////////
-
- int stringTableG::
- contains (const objG* O) const
- {return O->isImplementedAs(stringTokenG::Type)
- && Table[((stringTokenG*)O)->hash() % Buckets]
- ->contains((stringTokenG*)O);
- }
-
- int stringTableG::
- containsEqual (const objG* O) const
- {return O->isImplementedAs(stringTokenG::Type)
- && Table[((stringTokenG*)O)->hash() % Buckets]
- ->contains((stringTokenG*)O);
- }
-
- int stringTableG::
- canContain (const objG* O) const
- {return O->isImplementedAs(stringTokenG::Type);}
-
- void stringTableG::
- insert (const objG* O)
- {NOT_CONST();
- if(O->isImplementedAs(stringTokenG::Type))
- {int Hash = ((stringTokenG*)O)->hash() % Buckets;
- Table[Hash] = new stNodeP((stringTokenG*)O, Nil, Table[Hash]);
- }
- }
-
- void stringTableG::
- append (const bagG* B)
- {NOT_CONST();
- B->applyX(callSelf, this);
- }
-
- void stringTableG::
- apply (void (*F)(objA)) const
- {for(unsigned int I = 0; I < Buckets; ++I)
- for(stNodeP* N = Table[I]; N; N = N->Next)
- F(N->Token);
- }
-
- bagG* stringTableG::
- applyX (objA (*F)(objA), bagG* B) const
- {for(unsigned int I = 0; I < Buckets; ++I)
- {for(stNodeP* N = Table[I]; N; N = N->Next)
- {objA R = F(N->Token);
- B->insert(R.guts());
- }
- }
- return B;
- }
-
- bagG* stringTableG::
- applyX (bagA (*F)(objA), bagG* B) const
- {if(B->isType(tableG::Type))
- {tableG* T = (tableG*)B;
- for(unsigned int I = 0; I < Buckets; ++I)
- {for(stNodeP* N = Table[I]; N; N = N->Next)
- {bagA R = F(N->Token);
- T->insertAssoc(R.guts(), N->Obj.guts());
- }
- }
- }
- else
- {for(unsigned int I = 0; I < Buckets; ++I)
- {for(stNodeP* N = Table[I]; N; N = N->Next)
- {bagA R = F(N->Token);
- B->insert(R.guts());
- }
- }
- }
- return B;
- }
-
- bagA stringTableG::
- makeEmpty () const
- {return new stringTableG (Buckets);}
-
-
- // Table Operations //////////
-
- void stringTableG::
- insertAssoc (const objG* O, const objG* A)
- {NOT_CONST();
- if(O->isImplementedAs(stringTokenG::Type))
- {int Hash = ((stringTokenG*)O)->hash() % Buckets;
- Table[Hash] = new stNodeP((stringTokenG*)O, A, Table[Hash]);
- }
- }
-
- void stringTableG::
- reassoc (const objG* O, const objG* A)
- {NOT_CONST();
- if(O->isImplementedAs(stringTokenG::Type))
- {int Hash = ((stringTokenG*)O)->hash() % Buckets;
- if(!Table[Hash]->reassoc((stringTokenG*)O, A))
- Table[Hash] = new stNodeP((stringTokenG*)O, A, Table[Hash]);
- }
- }
-
- const objG* stringTableG::
- remove (const objG* O)
- {NOT_CONST();
- if(O->isImplementedAs(stringTokenG::Type))
- {unsigned int Hash = ((stringTokenG*)O)->hash() % Buckets;
- return Table[Hash]->remove((stringTokenG*)O, Table[Hash]);
- }
- else
- return Nil;
- }
-
- const objG* stringTableG::
- assoc (const objG* O) const
- {return O->isImplementedAs(stringTokenG::Type)
- ? Table[((stringTokenG*)O)->hash() % Buckets]
- ->assoc((stringTokenG*)O)
- : objG::Nil;
- }
-
-
- //***************************************************************************
-